src/github/mergePR.ts (1)

13-26: Consider wrapping fetch in try-catch for network failures.

Similar to postToSlackChannel, network-level errors (DNS, timeouts) will propagate uncaught. For consistency and resilience, consider catching and returning false.

♻️ Proposed fix to handle network errors

+  let response: Response;
+  try {
+    response = await fetch(
+      `https://api.github.com/repos/${repo}/pulls/${prNumber}/merge`,
+      {
+        method: "PUT",
+        headers: {
+          Authorization: `token ${token}`,
+          Accept: "application/vnd.github.v3+json",
+          "Content-Type": "application/json",
+        },
+        body: JSON.stringify({
+          merge_method: "squash",
+        }),
+      },
+    );
+  } catch (err) {
+    logger.error(`Network error merging PR #${prNumber} in ${repo}`, { error: String(err) });
+    return false;
+  }
-  const response = await fetch(
-    `https://api.github.com/repos/${repo}/pulls/${prNumber}/merge`,
-    {
-      method: "PUT",
-      headers: {
-        Authorization: `token ${token}`,
-        Accept: "application/vnd.github.v3+json",
-        "Content-Type": "application/json",
-      },
-      body: JSON.stringify({
-        merge_method: "squash",
-      }),
-    },
-  );

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@src/github/mergePR.ts` around lines 13 - 26, The fetch call in mergePR (the
request to `https://api.github.com/repos/${repo}/pulls/${prNumber}/merge`) can
throw network-level errors; wrap the await fetch in a try-catch inside the
mergePR function (or the surrounding async function) and on catch return false
(matching postToSlackChannel behavior), logging or preserving the error as
appropriate; ensure the existing response handling remains inside the try block
and only returns true/false after successful fetch/response processing.

src/github/fetchRecentSubmoduleCommits.ts (1)

18-53: Consider parallel fetching for improved performance.

Sequential fetching across 11 submodules introduces latency. Since these are independent API calls (not Trigger.dev wait or triggerAndWait calls), they can safely be parallelized with Promise.allSettled while still handling individual failures gracefully.

⚡ Proposed optimization using parallel fetching

 export async function fetchRecentSubmoduleCommits(): Promise<SubmoduleCommit[]> {
   const token = process.env.GITHUB_TOKEN;
-  const results: SubmoduleCommit[] = [];
+  const entries = Object.entries(SUBMODULE_CONFIG);
 
-  for (const [submodule, { repo }] of Object.entries(SUBMODULE_CONFIG)) {
-    try {
-      const response = await fetch(
+  const fetchPromises = entries.map(async ([submodule, { repo }]) => {
+    try {
+      const response = await fetch(
         `https://api.github.com/repos/${repo}/commits?per_page=5`,
         {
           headers: {
             Authorization: `token ${token}`,
             Accept: "application/vnd.github.v3+json",
           },
         },
       );
 
       if (!response.ok) {
         logger.warn(`Failed to fetch commits for ${repo}`, { status: response.status });
-        continue;
+        return null;
       }
 
       const data = (await response.json()) as Array<{
         sha: string;
         commit: { message: string; author: { name: string; date: string } };
       }>;
 
-      results.push({
+      return {
         submodule,
         repo,
         commits: data.map((c) => ({
           sha: c.sha.slice(0, 7),
           message: c.commit.message.split("\n")[0],
           author: c.commit.author.name,
           date: c.commit.author.date,
         })),
-      });
+      } as SubmoduleCommit;
     } catch (error) {
       logger.warn(`Error fetching commits for ${repo}`, { error });
+      return null;
     }
-  }
+  });
 
-  return results;
+  const results = await Promise.all(fetchPromises);
+  return results.filter((r): r is SubmoduleCommit => r !== null);
 }

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@src/github/fetchRecentSubmoduleCommits.ts` around lines 18 - 53, The current
loop in fetchRecentSubmoduleCommits iterates sequentially over SUBMODULE_CONFIG
causing high latency; refactor it to perform the per-repo fetches in parallel by
mapping Object.entries(SUBMODULE_CONFIG) to an array of fetch promises and using
Promise.allSettled to wait for all; for each settled result, if fulfilled
validate response.ok (log via logger.warn with repo and status on non-ok), parse
JSON safely and push the transformed commit objects (sha slice, first-line
message, author, date) into results, and if rejected log the error with
logger.warn including the repo and error details so individual failures don't
abort the whole operation.

src/github/getVercelPreviewUrl.ts (1)

21-53: Consider wrapping fetch calls in try-catch for network error resilience.

The function returns null on non-OK responses but doesn't handle network exceptions from fetch(). If a network error occurs, the exception will propagate up to the caller.

🛡️ Proposed fix to handle network errors

 export async function getVercelPreviewUrl(
   repo: string,
   prNumber: number,
 ): Promise<string | null> {
   const token = process.env.GITHUB_TOKEN;
   const headers = {
     Authorization: `token ${token}`,
     Accept: "application/vnd.github.v3+json",
   };
 
+  try {
     const prRes = await fetch(`https://api.github.com/repos/${repo}/pulls/${prNumber}`, {
       headers,
     });
 
     if (!prRes.ok) return null;
 
     const pr = (await prRes.json()) as { head: { sha: string } };
 
     const checksRes = await fetch(
       `https://api.github.com/repos/${repo}/commits/${pr.head.sha}/check-runs`,
       { headers },
     );
 
     if (!checksRes.ok) return null;
     // ... rest of the function
+  } catch (error) {
+    logger.warn(`Error fetching Vercel preview URL for PR #${prNumber}`, { error });
+    return null;
+  }
 }

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@src/github/getVercelPreviewUrl.ts` around lines 21 - 53, The fetch calls in
getVercelPreviewUrl (calls that produce prRes, checksRes, statusRes, etc.) can
throw on network errors but currently only check response.ok; wrap the sequence
of fetches in a try-catch around the network interactions (or at least each
await fetch) and return null (or log and return null) on caught exceptions so
network failures don't propagate; ensure you catch errors thrown by
fetch/response.json and apply the same null-return behavior the function already
uses for non-OK responses.

src/tasks/agentDayTask.ts (2)

46-50: Inconsistent indentation inside try block.

The code starting at line 47 should be indented one additional level within the try block. This appears to be a formatting issue.

♻️ Fix indentation

     try {
-    // Step 1: Gather recent commits to understand what has been built recently
-    logStep("Fetching recent commits from all submodules");
-    const recentCommits = await fetchRecentSubmoduleCommits();
+      // Step 1: Gather recent commits to understand what has been built recently
+      logStep("Fetching recent commits from all submodules");
+      const recentCommits = await fetchRecentSubmoduleCommits();

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@src/tasks/agentDayTask.ts` around lines 46 - 50, The code inside the try
block in agentDayTask.ts is mis-indented; adjust the indentation of the lines
starting with logStep("Fetching recent commits from all submodules"), the await
fetchRecentSubmoduleCommits() call, and the subsequent logStep("Recent commits
fetched", ...) so they are one additional level deeper (inside the try block) to
match block scope; ensure the statements around logStep and
fetchRecentSubmoduleCommits() are consistently indented and aligned with other
try/catch blocks or surrounding code.

---

144-153: Health check result is logged but not acted upon.

The Vercel preview health check captures the response status but doesn't fail the workflow or skip merge when the health endpoint returns an error status. If the preview is unhealthy, the PR will still be merged.

♻️ Proposed fix to skip merge on unhealthy preview

+          let previewHealthy = true;
           try {
             const healthRes = await fetch(`${previewUrl}/api/health`, {
               signal: AbortSignal.timeout(10_000),
             });
             logStep(`Preview health check for PR #${pr.number}`, true, {
               url: `${previewUrl}/api/health`,
               status: healthRes.status,
             });
+            if (!healthRes.ok) {
+              logger.warn(`Unhealthy preview for PR #${pr.number}`, { status: healthRes.status });
+              previewHealthy = false;
+            }
           } catch (error) {
             logger.warn(`Preview health check failed for PR #${pr.number}`, { error });
+            previewHealthy = false;
           }
+
+          if (!previewHealthy) {
+            logger.warn(`Skipping merge for PR #${pr.number} due to unhealthy preview`);
+            continue;
+          }

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@src/tasks/agentDayTask.ts` around lines 144 - 153, The health-check fetch in
agentDayTask.ts currently only logs the response but doesn't stop processing on
non-2xx responses; after awaiting fetch (healthRes) check healthRes.ok (or
healthRes.status) and, if not healthy, throw or set a "previewUnhealthy"
error/flag so the caller can skip merge; update the try block that calls
fetch(`${previewUrl}/api/health`, ...) to treat non-ok responses as failures
(use existing logStep/logger.warn for context) and ensure the surrounding flow
(merge decision) observes that thrown error/flag to prevent merging an unhealthy
preview.

src/ai/assessPRFeedback.ts (1)

77-88: Consider validating parsed JSON with Zod.

The type assertion as FeedbackAssessment doesn't guarantee the parsed object has the required fields. Malformed AI output could lead to undefined values propagating downstream.

♻️ Proposed Zod validation

+import { z } from "zod";
+
+const FeedbackAssessmentSchema = z.object({
+  hasActionableFeedback: z.boolean(),
+  feedbackSummary: z.string(),
+  implementation: z.string(),
+});
+
 // In the try block:
     try {
-      const parsed = JSON.parse(text) as FeedbackAssessment;
+      const parsed = FeedbackAssessmentSchema.parse(JSON.parse(text));
       logStep("PR feedback assessment complete", false, {

As per coding guidelines: "Use Zod for schema validation" applies to src/**/*.{ts,tsx} files.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@src/ai/assessPRFeedback.ts` around lines 77 - 88, Replace the unchecked JSON
assertion with Zod validation: define a Zod schema for FeedbackAssessment
(fields like hasActionableFeedback and feedbackSummary), parse the raw text with
JSON.parse into a temp value then run FeedbackAssessmentSchema.safeParse(temp)
inside the try; if safeParse succeeds return the validated data, otherwise log
the validation errors via logStep (include the sliced text and the
safeParse.error) and return noFeedback. Update the block using the symbols
parsed, FeedbackAssessment, FeedbackAssessmentSchema (or similar), logStep, and
noFeedback so downstream code gets a fully validated object.